package com.fun.frame;


import com.fun.frame.utils.Output;
import com.fun.utils.Regex;
import com.fun.utils.Time;
import net.sf.json.JSONObject;
import org.apache.commons.lang3.ArrayUtils;
import org.apache.commons.lang3.StringUtils;

import java.util.Arrays;
import java.util.List;
import java.util.Random;
import java.util.Scanner;


public class SourceCode extends Output {

    /**
     * 获取当前时间戳10位int 类型的数据
     *
     * @return
     */
    public static int getMark() {
        return (int) (Time.getTimeStamp() / 1000);
    }

    /**
     * 等待方法，用sacnner类，控制台输出字符key时会跳出循环
     *
     * @param key
     */
    public static void waitForKey(Object key) {
        long start = Time.getTimeStamp();
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()) {
            String next = scanner.next();
            if (next.equals(key.toString())) break;
        }
        scanner.close();
        long end = Time.getTimeStamp();
        double timeDiffer = Time.getTimeDiffer(start, end);
        String message = "本次共等待：" + timeDiffer + "秒！";
    }

    /**
     * 将数组变成json对象，使用split方法
     *
     * @param objects
     * @param regex
     * @return
     */
    public static JSONObject changeArraysToJson(Object[] objects, String regex) {
        JSONObject args = new JSONObject();
        for (int i = 0; i < objects.length; i++) {
            String[] str = objects[i].toString().split(regex, 2);
            args.put(str[0], str[1]);
        }
        return args;
    }

    /**
     * 获取一个简单的json对象
     *
     * @param content
     * @return
     */
    public static JSONObject getJson(Object... content) {
        JSONObject json = new JSONObject();
        for (int i = 0; i < content.length; i++) {
            String[] split = content[i].toString().split("=", 2);
            json.put(split[0], split[1]);
        }
        return json;
    }

    /**
     * 将数组转化为list，为基础数据类型
     *
     * @param objects
     * @return
     */
    public static List<Integer> changeArraysToList(int[] objects) {
        Integer[] integers = ArrayUtils.toObject(objects);
        return Arrays.asList(integers);
    }


    /**
     * 获取格式化输出的文本，自动拼接space
     *
     * @param text
     * @return
     */
    public static String getFormat(String text) {
        return text + getManyString(SPACE_1, STRING_FORMAT_LIMIT - text.length());
    }

    /**
     * 获取text复制拼接的string
     *
     * @param text
     * @param time 增加的倍数
     * @return
     */
    public static String getManyString(String text, int time) {
        String str = text;
        for (int i = 0; i < time; i++) {
            str = str + text;
        }
        return str;
    }

    /**
     * 获取一个百分比，两位小数
     *
     * @param total 总数
     * @param piece 成功数
     * @return 百分比
     */
    public static double getPercent(int total, int piece) {
        if (total == 0) return 0.00;
        if (total == piece) {
            return 100.00;
        }
        int s = (int) (piece * (1.0) / total * 10000);
        double result = s * 1.0 / 100;
        return result;
    }

    /**
     * 统计数据出现的次数
     *
     * @param counts 统计的 jsonobject 对象
     * @param object 需要统计的数据
     */
    public static void countCount(JSONObject counts, Object object) {
        if (counts != null && counts.containsKey(object.toString())) {
            int i = counts.getInt(object.toString()) + 1;
            counts.put(object.toString(), i);
        } else {
            counts.put(object.toString(), 1);
        }
    }

    /**
     * 删除字符，只删除第一个，不匹配正则
     *
     * @param delChar 要删除的字符
     * @param text    被删除的字符串
     * @return 返回删除后的字符串
     */
    public static String deleteCharFromString(String delChar, String text) {
        int index = text.indexOf(delChar);
        int length = delChar.length();
        int total = text.length();
        text = text.substring(0, index) + text.substring(0 + length, total);
        return text;
    }

    /**
     * 获取随机IP地址
     *
     * @return
     */
    public static String getRandomIP() {
        return getRandomInt(255) + "." + getRandomInt(255) + "." + getRandomInt(255) + "." + getRandomInt(255);
    }

    /**
     * 解析json信息
     *
     * @param response json格式的响应实体
     * @return json每个字段和值，key:value形式
     */
    public static List<String> parseJsonLines(JSONObject response) {
        String jsonStr = response.toString();// 先将json对象转化为string对象
        jsonStr = jsonStr.replaceAll(",", LINE);
        jsonStr = jsonStr.replaceAll("\"", EMPTY);
        jsonStr = jsonStr.replaceAll("\\\\/", OR);
        jsonStr = jsonStr.replaceAll("\\{", LINE);
        jsonStr = jsonStr.replaceAll("\\[", LINE);
        jsonStr = jsonStr.replaceAll("}", LINE);
        jsonStr = jsonStr.replaceAll("]", LINE);
        List<String> jsonLines = Arrays.asList(jsonStr.split(LINE));
        return jsonLines;
    }

    /**
     * 把string类型转化为int
     *
     * @param text 需要转化的文本
     * @return
     */
    public static int changeStringToInt(String text) {
        try {
            // return Integer.valueOf(text);
            return Integer.parseInt(text);
        } catch (NumberFormatException e) {
            output("转化int类型失败！", e);
            return TEST_ERROR_CODE;
        }
    }

    /**
     * 把长字符串转化为list集合
     *
     * @param text
     * @param regex
     * @return
     */
    public static List<String> changeStringToList(String text, String regex) {
        String[] split = text.split(regex);
        return Arrays.asList(split);
    }

    /**
     * 把字符串每个字符用分隔器连接起来
     *
     * @param text
     * @param separator
     * @return
     */
    public static String joinStringBySeparator(String text, String separator) {
        return StringUtils.join(ArrayUtils.toObject(text.toCharArray()), separator);
    }

    /**
     * string转化为double
     *
     * @param text
     * @return
     */
    public static Double changeStringToDouble(String text) {
        try {
            return Double.parseDouble(text);
            // return Double.valueOf(text);
        } catch (NumberFormatException e) {
            output("转化double类型失败！");
            return TEST_ERROR_CODE * 1.0;
        }
    }

    /**
     * 是否是数字，000不算
     *
     * @param text
     * @return
     */
    public static boolean isNumber(String text) {
        if (text == null || text.isEmpty()) return false;
        if (text.equals("0")) return true;
        return Regex.isRegex(text, "^[1-9][0-9]*$");
    }

    /**
     * 线程休眠，超过30，单位是毫秒，小于等于30，单位是秒
     *
     * @param second 秒，可以是小数
     */
    public static void sleep(int second) {
        try {
            if (second > 30) Thread.sleep(second);
            if (second <= 30) Thread.sleep(second * 1000);
        } catch (InterruptedException e) {
            output("sleep发生错误！");
        }
    }

    /**
     * 获取随机数，获取1~num 的数字，包含 num
     *
     * @param num 随机数上限
     * @return 随机数
     */
    public static int getRandomInt(int num) {
        return new Random().nextInt(num) + 1;
    }

    /**
     * 获取一定范围内的随机值
     *
     * @param start 初始值
     * @param range 随机范围
     * @return
     */
    public static double getRandomRange(double start, double range) {
        return start - range + getRandomDouble() * range * 2;
    }

    /**
     * 获取随机数，获取0-1 的数字，包含 num
     *
     * @return 随机数
     */
    public static double getRandomDouble() {
        return new Random().nextDouble();
    }

    /**
     * 随机获取给定数组里面的一个元素
     *
     * @param list
     * @return
     */
    public static String getRandomString(String... list) {
        int randomInt = getRandomInt(list.length - 1);
        return list[randomInt].toString();
    }


}